const express = require('express');
const Busboy = require('busboy')
const path = require('path')
const fs = require('fs')
const { getOpenAIResponse,createStreamingChatCompletion } = require('../utils/openai.js')
const router = express.Router()
const JWT = require('../utils/jwt')
const connection = require('../db/db')
const bcrypt = require('bcryptjs')
const RSA = require('../utils/rsa')
const axios = require('axios');
const rsa = new RSA()
// 邮箱发送消息
var nodemailer = require('nodemailer');
//开启一个 SMTP 连接池
var transport = nodemailer.createTransport({
    host : 'smtp.qq.com', //QQ邮箱的 smtp 服务器地址
    secure : true, //使用 SSL 协议
    secureConnection : false, //是否使用对 https 协议的安全连接
    port : 465, //QQ邮件服务所占用的端口
    auth : {
        user : '3241928859@qq.com', //开启 smtp 服务的发件人邮箱，用于发送邮件给其他人
        pass : 'dmcuhqegaveidbcg' //SMTP 服务授权码
    }
})

var mailOption = {
    from : '3241928859@qq.com', //发件人
    to : '1944978223@qq.com', //收件人
    subject : '小猪下单提醒', //标题
    html : '<b>陈小猪下单啦，请尽快前往查看</b>' //正文，可使用 HTML 格式进行渲染
}

// 版本更新推送
router.get('/getVersionUpdate',async (req,res)=>{
    let { version = '' } = req.query;
    const appVersion = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../utils/appVersion.json'), 'utf8'));
    console.log(appVersion.version);
    if(version == appVersion.version){
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'已是最新版本', //状态描述
            data:1	  // 需要响应给客户端的具体数据
        })
    }else{
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'有新版本', //状态描述
            data:process.env.BASE_HOST+'/uploads/app.apk',	  // 需要响应给客户端的具体数据
        })
    }
})

// 根据token获取用户信息
async function getUserInfo(token){
    return new Promise((resolve,reject)=>{
        if(!token){
            resolve(false)
            return
        }
        const info = JWT.verifyToken(token.split(' ')[1])
        if(info){
            connection.query('SELECT * FROM user WHERE id=?;',[info.id],(err, results) => {
                if(results&&results.length){
                    resolve(results[0])
                }else{
                    resolve(false)
                }
            })
        }else{
            resolve(false)
        }
    })
}

// 影片查询
router.get('/searchVideoList',async (req,res)=>{
    let { keyword = '', count='20' } = req.query;
    axios.get(`https://search.lziapi.com/json-api/?dname=liangzi&key=${keyword}&count=${count}`)
    .then((response) => {
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'查询成功', //状态描述
            data:response.data		  // 需要响应给客户端的具体数据
        })
    })
    .catch((error) => {
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'接口异常,请联系管理员', //状态描述
            data:error		  // 需要响应给客户端的具体数据
        })
    });
})

// 保存定位
router.post('/savePosition',async (req,res)=>{
    if(req.body){
        console.log(req.body);
        
        req.body.id = parseInt(Math.random() * 1000000000000)
        req.body.createTime = new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', hour12: false })
        const { id,latitude,longitude,userId,createTime } = req.body
        const sql = "INSERT INTO `position` (`id`,`latitude`,`longitude`,`userId`,`createTime`) VALUES (?,?,?,?,?)";
        const params = [id,latitude,longitude,userId,createTime];
        connection.query(sql, params, (err, results) => {
            if (err) {
                console.log(err);
                
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'添加失败,请联系管理员', //状态描述
                    data:null		  // 需要响应给客户端的具体数据
                })
                return;
            }
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'添加成功', //状态描述
                data:req.body.id		  // 需要响应给客户端的具体数据
            })
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'添加失败,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})
// 获取定位
router.post('/getPosition', async (req, res) => {
    let { userId='', pageNum = 1, pageSize = 5 } = req.body;
    try {
        pageNum = parseInt(pageNum);
        pageSize = parseInt(pageSize);
    } catch (error) {
        pageNum = 1;
        pageSize = 5;
    }
    let total = 0;
    if (userId) {
        connection.query('SELECT COUNT(*) AS total FROM `position` WHERE userId=?;', [userId], (err, countResults) => {
            if (countResults && countResults.length) {
                total = countResults[0].total;
                connection.query('SELECT * FROM `position` WHERE userId=? ORDER BY createTime DESC LIMIT ?, ?;', [userId, (pageNum - 1) * pageSize, pageSize], (err, results) => {
                    if (results instanceof Array) {
                        const data = results.map(({ latitude, longitude, id, createTime }) => ({
                            id,
                            userId,
                            latitude,
                            longitude,
                            createTime: new Date(createTime).toLocaleString(),
                        }));
                        res.send({
                            status: 0, // 状态，0表示成功，1表示失败
                            message: '查询成功', // 状态描述
                            data:{
                                list: data, // 需要响应给客户端的具体数据
                                total, // 总条数
                                pageNum, // 当前页码
                                pageSize, // 每页条数
                            }, // 需要响应给客户端的具体数据
                        });
                    } else {
                        res.status(500).send({
                            status: 1, // 状态，0表示成功，1表示失败
                            message: '查询失败', // 状态描述
                            data: null, // 需要响应给客户端的具体数据
                        });
                    }
                });
            } else {
                res.status(500).send({
                    status: 1, // 状态，0表示成功，1表示失败
                    message: '查询失败', // 状态描述
                    data: null, // 需要响应给客户端的具体数据
                });
            }
        });
    } else {
        connection.query('SELECT COUNT(*) AS total FROM `position`', [], (err, countResults) => {
            if (countResults && countResults.length) {
                total = countResults[0].total;
                connection.query('SELECT * FROM `position` ORDER BY createTime DESC LIMIT ?, ?;', [(pageNum - 1) * pageSize, pageSize], (err, results) => {
                    if (results instanceof Array) {
                        const data = results.map(({ latitude, longitude, id,userId, createTime }) => ({
                            id,
                            userId,
                            latitude,
                            longitude,
                            createTime: new Date(createTime).toLocaleString(),
                        }));
                        res.send({
                            status: 0, // 状态，0表示成功，1表示失败
                            message: '查询成功', // 状态描述
                            data:{
                                list: data, // 需要响应给客户端的具体数据
                                total, // 总条数
                                pageNum, // 当前页码
                                pageSize, // 每页条数
                            }, // 需要响应给客户端的具体数据
                        });
                    } else {
                        res.status(500).send({
                            status: 1, // 状态，0表示成功，1表示失败
                            message: '查询失败', // 状态描述
                            data: null, // 需要响应给客户端的具体数据
                        });
                    }
                });
            } else {
                res.status(500).send({
                    status: 1, // 状态，0表示成功，1表示失败
                    message: '查询失败', // 状态描述
                    data: null, // 需要响应给客户端的具体数据
                });
            }
        });
    }
});

//挂载对应的路由

// 文件上传接口
// 处理上传文件服务
router.post('/upload', (req, res) => {
    // res.setHeader("Access-Control-Allow-Origin", "*");
    const bb = Busboy({ headers: req.headers });
    
    let data = {
        filename:'', // 图片名字
        encoding:'', // 图片大小
        mimeType:'', // 图片格式
        imgUrl:'' // 图片地址
    }

    bb.on('file', (name, file, info) => {
        // 名字 大小 格式
        const { filename, encoding, mimeType } = info;
        // 根据时间创建名字 - 防止重名
        const fileName = new Date().getTime() + path.extname(filename)
        // 保存数据
        data = {...info,fileName:fileName}
        // 拼接地址
        const saveTo = path.join(__dirname, '../files/uploads', fileName);
        // 写入流
        file.pipe(fs.createWriteStream(saveTo));
    }); 

    bb.on('finish', function () {
        // 地址回显
        // data.fileUrl = 'http://192.168.82.22:3000/uploads/' + data.fileName
        data.fileUrl = '/uploads/' + data.fileName
        // 返回图片
        res.send({
            code:200,
            msg:'上传成功',
            data
        });
    });

    return req.pipe(bb);
});
// aiTest
router.post('/chatAi',async (req,res)=>{
    let { type='',msg='' } = req.body
    // 加载提示词
    let infoList = fs.readFileSync(path.resolve(__dirname, '../utils/chatHistory.json'), 'utf8');
    let list = JSON.parse(infoList)

    // 获取菜单
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT * FROM menuType WHERE adminId=? ORDER BY sort ASC;',[info.adminId],(err, results) => {
        if(results || results == []){
            connection.query('SELECT * FROM menu WHERE adminId=?;',[info.adminId],async (err, results) => {
                if(results && results.length > 0){
                    let menuList = results.map(e=>{
                        return {name:e.name,id:e.id,typeName:e.typeName}
                    })
                    list.push({ role: 'user', content: JSON.stringify(menuList)+'以上是菜单数据,id为菜品id,name为菜品名称,typeName为菜品类型' })
                    if(type && type != '随机点菜'){
                        list.push({
                            role: 'user',
                            content: `根据已有的菜单数据,无需考虑营养搭配,请帮我随机选择1~2道菜,并严格根据格式返回,不要有其他任何多余的回复，格式如下：{ids:菜品id集合,reason:原因},返回的格式必须是一个标准的json对象,ids为多个菜品id拼接成的字符串,reason为菜品名称和你对这些菜的描述，多个菜品id用逗号拼接,菜品id来源根据下面提供的菜单数据中获取，请务必保证id正确。要求菜品类型(typeName)必须是${type}。`
                        })
                    }else if(type == '随机点菜'){
                        list.push({
                            role: 'user',
                            content: `根据已有的菜单数据,无需考虑营养搭配,请帮我随机选择2~3道菜,并严格根据格式返回,不要有其他任何多余的回复，格式如下：{ids:菜品id集合,reason:原因},返回的格式必须是一个标准的json对象,ids为多个菜品id拼接成的字符串,reason为菜品名称和你对这些菜的描述，多个菜品id用逗号拼接,菜品id来源根据下面提供的菜单数据中获取，请务必保证id正确。`
                        })
                    }else if(msg){
                        list.push({
                            role: 'user',
                            content: msg
                        })
                    }
                    console.log(list);
                    let content = await getOpenAIResponse(list)
                    console.log(content);
                    res.send({
                        status:0,			//状态，0表示成功，1表示失败
                        message:'成功', //状态描述
                        data:content     // 需要响应给客户端的具体数据
                    })
                }else{
                    res.status(500).send({
                        status:1,			//状态，0表示成功，1表示失败
                        message:'当前没有可供点菜的菜单！', //状态描述
                        data:null          // 需要响应给客户端的具体数据
                    })
                }
            })
        }
    })
})
// 流式聊天
router.post('/chatAiStream',async (req,res)=>{
    let { msg='' } = req.body
    // 加载提示词
    let infoList = fs.readFileSync(path.resolve(__dirname, '../utils/chatHistory.json'), 'utf8');
    let list = JSON.parse(infoList)

    // 获取菜单
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT * FROM menuType WHERE adminId=? ORDER BY sort ASC;',[info.adminId],(err, results) => {
        if(results || results == []){
            connection.query('SELECT * FROM menu WHERE adminId=?;',[info.adminId],async (err, results) => {
                if(results && results.length > 0){
                    let menuList = results.map(e=>{
                        return {name:e.name,id:e.id,typeName:e.typeName}
                    })
                    list.push({ role: 'user', content: JSON.stringify(menuList)+'以上是菜单数据,id为菜品id,name为菜品名称,typeName为菜品类型' })
                    list.push({
                        role: 'user',
                        content: msg
                    })
                    console.log(list);
                    try {
                        // 设置响应头以支持流式输出
                        res.writeHead(200, {
                            'Content-Type': 'text/plain; charset=utf-8',
                            'Transfer-Encoding': 'chunked',
                            'Cache-Control': 'no-cache',
                            'Connection': 'keep-alive',
                            'Access-Control-Allow-Origin': '*',
                            'Access-Control-Allow-Headers': 'Content-Type'
                        });
                
                        // 使用封装的流式函数
                        await createStreamingChatCompletion(
                            list,
                            // onChunk 回调：发送数据块到客户端
                            (chunk) => {
                                console.log(chunk);
                                
                                res.write(chunk);
                            },
                            // onComplete 回调：结束响应
                            () => {
                                res.end();
                            },
                            // onError 回调：处理错误
                            (error) => {
                                console.error('流式请求失败:', error.message);
                                res.write(`错误: ${error.message}`);
                                res.end();
                            }
                        );
                
                    } catch (error) {
                        console.error('聊天接口失败:', error.message);
                        if (!res.headersSent) {
                            res.status(500).send({
                                status:1,			//状态，0表示成功，1表示失败
                                message:error.message , //状态描述
                                data:null          // 需要响应给客户端的具体数据
                            })
                        } else {
                            res.write(`错误: ${error.message}`);
                            res.end();
                        }
                    }
                }else{
                    res.status(500).send({
                        status:1,			//状态，0表示成功，1表示失败
                        message:'当前没有可供点菜的菜单！', //状态描述
                        data:null          // 需要响应给客户端的具体数据
                    })
                }
            })
        }
    })
})

// 获取管理后台菜单列表
router.post('/getMenuList',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { keyWords='',pageNum=1,pageSize=5 } = req.body
    try {
        pageNum = parseInt(pageNum)
        pageSize = parseInt(pageSize)
    } catch (error) {
        pageNum = 1
        pageSize = 5
    }
    // 先查询总条数
    connection.query('SELECT COUNT(*) as total FROM menu WHERE adminId=? AND (typeName LIKE CONCAT("%",?,"%") OR name LIKE CONCAT("%",?,"%"));',[info.id,keyWords,keyWords],(err, countResults) => {
        if(err){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
            return
        }
        const total = countResults[0].total
        // 查询分页数据
        connection.query('SELECT * FROM menu WHERE adminId=? AND (typeName LIKE CONCAT("%",?,"%") OR name LIKE CONCAT("%",?,"%")) LIMIT ?, ?;',[info.id,keyWords,keyWords,(pageNum-1)*pageSize,pageSize],(err, results) => {
            if(results || results == []){
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'查询成功', //状态描述
                    data:{
                        list: results,          // 数据列表
                        total: total,           // 总条数
                        pageNum: pageNum,       // 当前页码
                        pageSize: pageSize      // 每页条数
                    }
                })
            }else{
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'查询失败', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        })
    })
})
// 根据id获取菜品信息
router.get('/getMenuInfo',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { id='' } = req.query
    connection.query('SELECT * FROM menu WHERE id=? AND adminId=?;',[id,info.id],(err, results) => {
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results.length?results[0]:null          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 获取首页展示的菜单列表
router.get('/getUserMenuList',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let list = []
    connection.query('SELECT * FROM menuType WHERE adminId=? ORDER BY sort ASC;',[info.adminId],(err, results) => {
        if(results || results == []){
            list = results
            connection.query('SELECT * FROM menu WHERE adminId=?;',[info.adminId],(err, results) => {
                if(results || results == []){
                    results.forEach(e=>{
                        list.forEach(p=>{
                            if(p.typeCode == e.typeCode){
                                if(p.productList instanceof Array){
                                    p.productList.push(e)
                                }else{
                                    p.productList = []
                                    p.productList.push(e)
                                }
                            }
                        })
                    })
                    res.send({
                        status:0,			//状态，0表示成功，1表示失败
                        message:'查询成功', //状态描述
                        data:list       // 需要响应给客户端的具体数据
                    })
                }else{
                    res.status(500).send({
                        status:1,			//状态，0表示成功，1表示失败
                        message:'查询失败', //状态描述
                        data:null          // 需要响应给客户端的具体数据
                    })
                }
            })
        }
    })
})
// 添加菜单数据
router.post('/addMenuInfo', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        req.body.id = parseInt(Math.random() * 1000000000000)
        req.body.adminId = info.id
        const { id,typeName,typeCode,name,num,price,description,coverImg,adminId } = req.body
        const sql = "INSERT INTO menu(`id`,`typeName`,`typeCode`,`name`,`num`,`price`,`description`,`coverImg`,`adminId`) VALUES (?,?,?,?,?,?,?,?,?)";
        const params = [id,typeName,typeCode,name,num,price,description,coverImg,adminId];
        connection.query(sql, params, (err, results) => {
            if (err) {
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'添加失败,请联系管理员', //状态描述
                    data:null		  // 需要响应给客户端的具体数据
                })
                return;
            }
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'添加成功', //状态描述
                data:req.body.id		  // 需要响应给客户端的具体数据
            })
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'添加失败,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
    
})
// 修改菜单数据
router.post('/updateMenuInfo', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        const { id,typeName,typeCode,name,num,price,description,coverImg } = req.body
        const sql = "UPDATE menu set typeName=?,typeCode=?,name=?,num=?,price=?,description=?,coverImg=? WHERE id=? && adminId=?";
        const params = [typeName,typeCode,name,num,price,description,coverImg,id,info.id];
        connection.query(sql, params, (err, results) => {
            if(results.affectedRows==1){
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'修改成功', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }else{
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'接口异常，请联系管理员', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'接口异常,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})
// 删除菜单数据
router.get('/deleteMenuInfo', async (req,res)=>{
    let { id } = req.query
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query("DELETE FROM menu WHERE id = ? AND adminId = ?;",[id,info.id],(err, results) => {
        if(err || results.affectedRows == 0){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'删除失败', //状态描述
                data:err          // 需要响应给客户端的具体数据
            })
            return
        }
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'删除成功', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
    })
})

// 获取全部菜单分类
router.post('/getMenuTypeList',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { keyWords='',pageNum=1,pageSize=5 } = req.body
    try {
        pageNum = parseInt(pageNum)
        pageSize = parseInt(pageSize)
    } catch (error) {
        pageNum = 1
        pageSize = 5
    }
    // 先查询总条数
    connection.query('SELECT COUNT(*) as total FROM menuType WHERE adminId=? AND typeName LIKE CONCAT("%",?,"%");',[info.id,keyWords],(err, countResults) => {
        if(err){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
            return
        }
        const total = countResults[0].total
        // 查询分页数据
        connection.query('SELECT * FROM menuType WHERE adminId=? AND typeName LIKE CONCAT("%",?,"%") ORDER BY sort ASC LIMIT ?, ?;',[info.id,keyWords,(pageNum-1)*pageSize,pageSize],(err, results) => {
            if(results || results == []){
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'查询成功', //状态描述
                    data:{
                        list: results,          // 数据列表
                        total: total,           // 总条数
                        pageNum: pageNum,       // 当前页码
                        pageSize: pageSize      // 每页条数
                    }
                })
            }else{
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'查询失败', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        })
    })
})
// 根据id获取菜单分类
router.get('/getMenuType',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { id='' } = req.query
    connection.query('SELECT * FROM menuType WHERE id=? AND adminId=?;',[id,info.id],(err, results) => {
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results.length?results[0]:null          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 添加菜单分类
router.post('/addMenuType', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        req.body.id = parseInt(Math.random() * 1000000000000)
        req.body.adminId = info.id
        const { id,typeName,typeCode,sort,adminId } = req.body
        const sql = "INSERT INTO menuType(`id`,`typeName`,`typeCode`,`sort`,`adminId`) VALUES (?,?,?,?,?)";
        const params = [id,typeName,typeCode,sort,adminId];
        connection.query(sql, params, (err, results) => {
            if (err) {
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'添加失败,请联系管理员', //状态描述
                    data:null		  // 需要响应给客户端的具体数据
                })
                return;
            }
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'添加成功', //状态描述
                data:req.body.id		  // 需要响应给客户端的具体数据
            })
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'添加失败,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
    
})
// 修改菜单分类
router.post('/updateMenuType', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        const { id,typeName,typeCode,sort } = req.body
        const sql = "UPDATE menuType set typeName=?,typeCode=?,sort=? WHERE id=? && adminId=?";
        const params = [typeName,typeCode,sort,id,info.id];
        connection.query(sql, params, (err, results) => {
            if(results.affectedRows==1){
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'修改成功', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }else{
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'接口异常，请联系管理员', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'接口异常,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})
// 删除菜单分类
router.get('/deleteMenuType', async (req,res)=>{
    let { id } = req.query
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query("DELETE FROM menuType WHERE id = ? AND adminId = ?;",[id,info.id],(err, results) => {
        if(err || results.affectedRows == 0){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'删除失败', //状态描述
                data:err          // 需要响应给客户端的具体数据
            })
            return
        }
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'删除成功', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
    })
})

// 获取轮播图
router.post('/getSwipeList', async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { keyWords='',pageNum=1,pageSize=5 } = req.body
    try {
        pageNum = parseInt(pageNum)
        pageSize = parseInt(pageSize)
    } catch (error) {
        pageNum = 1
        pageSize = 5
    }
    connection.query('SELECT * FROM swipe WHERE adminId=? AND title LIKE CONCAT("%",?,"%") LIMIT ?, ?;',[info.id,keyWords,(pageNum-1)*pageSize,pageSize],(err, results) => {
        console.log(err,results);
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 根据id获取轮播图
router.get('/getSwipeInfo',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    let { id='' } = req.query
    connection.query('SELECT * FROM swipe WHERE id=? AND adminId=?;',[id,info.id],(err, results) => {
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results.length?results[0]:null          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 获取首页展示的轮播图
router.get('/getUserSwipeList',async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT * FROM swipe WHERE adminId=?;',[info.adminId],(err, results) => {
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results       // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 添加轮播图数据
router.post('/addSwipeInfo', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        req.body.id = parseInt(Math.random() * 1000000000000)
        const { id,url,title } = req.body
        const sql = "INSERT INTO swipe(`id`,`url`,`title`,`adminId`) VALUES (?,?,?,?)";
        const params = [id,url,title,info.id];
        connection.query(sql, params, (err, results) => {
            console.log(err);
            if (err) {
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'添加失败,请联系管理员', //状态描述
                    data:null		  // 需要响应给客户端的具体数据
                })
                return;
            }
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'添加成功', //状态描述
                data:req.body.id		  // 需要响应给客户端的具体数据
            })
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'添加失败,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
   
})
// 修改轮播图数据
router.post('/editSwipeInfo', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        const { id,url,title } = req.body
        const sql = "UPDATE swipe set url=?,title=? WHERE id=? && adminId=?";
        const params = [url,title,id,info.id];
        connection.query(sql, params, (err, results) => {
            if(results.affectedRows==1){
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'修改成功', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }else{
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'接口异常，请联系管理员', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'接口异常,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})
// 删除轮播图数据
router.get('/deleteSwipeInfo', async (req,res)=>{
    let { id } = req.query
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query("DELETE FROM swipe WHERE id = ? AND adminId = ?;",[id,info.id],(err, results) => {
        if(err || results.affectedRows == 0){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'删除失败', //状态描述
                data:err          // 需要响应给客户端的具体数据
            })
            return
        }
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'删除成功', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
    })
})

// 新增订单
router.post('/addOrderInfo', async (req,res)=>{
    if(req.body){
        try {
            let token = req.get('Authorization')
            let info = await getUserInfo(token)
            const { list=[],totalPrice,remark='' } = req.body
            
            // 检查余额
            if(parseFloat(info.balance)-parseFloat(totalPrice)<0){
                res.status(500).send({
                    status:1,
                    message:'余额不足！',
                    data:null
                })
                return
            }

            // 将普通的connection转换为支持Promise的形式
            const query = (sql, values) => {
                return new Promise((resolve, reject) => {
                    connection.query(sql, values, (err, results) => {
                        if (err) {
                            reject(err)
                        } else {
                            resolve(results)
                        }
                    })
                })
            }

            // 开启事务
            await new Promise((resolve, reject) => {
                connection.beginTransaction(err => {
                    if (err) reject(err)
                    else resolve()
                })
            })

            try {
                let orderContentId = parseInt(Math.random() * 1000000000000)
                let strArr = []
                
                // 构建订单详情数据
                let dataList = list?.map(e=>{
                    strArr.push(e.name)
                    return `(
                        ${parseInt(Math.random() * 1000000000000)},
                        ${orderContentId},
                        ${e.id}, 
                        ${e.count},
                        '${e.name}',
                        ${e.price},
                        '${e.typeName}',
                        '${e.typeCode}',
                        '${e.coverImg || ''}',
                        ${e.price * e.count},
                        '${e.remark || ''}',
                        '${e.description || ''}'
                    )`
                }).join(', ')
                console.log(dataList,"??????");
                
                // 插入订单详情
                await query(`
                    INSERT INTO orderContent (
                        id, orderContentId, menuId, count, 
                        dishName, dishPrice, dishTypeName, dishTypeCode,
                        dishImg, subtotal, remark, description
                    ) VALUES ${dataList};
                `)

                // 插入订单主表
                await query(
                    `INSERT INTO orders (
                        id, createTime, orderContentId, userId, 
                        adminId, totalPrice, remark, status, payStatus
                    ) VALUES (?,?,?,?,?,?,?,1,0);`,
                    [
                        parseInt(Math.random() * 1000000000000),
                        new Date(),
                        orderContentId,
                        info.id,
                        info.adminId,
                        totalPrice,
                        remark
                    ]
                )

                // 更新用户余额
                let pass = await changePrice(info.id,'subtract',totalPrice,info.balance)
                if(!pass) throw new Error('余额更新失败')

                // 发送邮件通知
                mailOption.html = `<b>${info.nickName}，下单了<string style="color:blue;">${strArr.join('、')}</string>,请尽快前往查看</b>`
                await new Promise((resolve, reject) => {
                    transport.sendMail(mailOption, (err, info) => {
                        if (err) reject(err)
                        else resolve(info)
                    })
                })

                // 提交事务
                await new Promise((resolve, reject) => {
                    connection.commit(err => {
                        if (err) reject(err)
                        else resolve()
                    })
                })

                res.send({
                    status:0,
                    message:'下单成功',
                    data:null
                })

            } catch (error) {
                // 回滚事务
                await new Promise((resolve) => {
                    connection.rollback(() => resolve())
                })
                throw error
            }

        } catch (error) {
            console.error('下单错误:', error)
            res.status(500).send({
                status:1,
                message:'下单失败，请稍后重试',
                data:null
            })
        }
    } else {
        res.status(500).send({
            status:1,
            message:'参数错误',
            data:null
        })
    }
})
// 查询最新的一条订单
router.get('/getOrderNewInfo', async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT * FROM orders WHERE userId=? AND adminId=? ORDER BY createTime DESC LIMIT 1;',[info.id,info.adminId],(err, results) => {
        if(err){
            res.status(500).send({
                status:1,
                message:'接口异常,请联系管理员',
                data:null
            })
            return
        }
        if(results && results.length){
            let orderContentId = results[0].orderContentId
            let data = {
                ...results[0],
                list:[]
            }
            // 直接从orderContent表获取数据，不需要关联menu表
            connection.query('SELECT * FROM orderContent WHERE orderContentId=?;',[orderContentId],(err, results) => {
                if(results){
                    data.list = results
                    res.send({
                        status:0,
                        message:'查询成功',
                        data:data
                    })
                }else{
                    res.status(500).send({
                        status:1,
                        message:'接口异常,请联系管理员',
                        data:null
                    })
                }
            })
        }else{
            res.send({
                status:0,
                message:'查询成功',
                data:null
            })
        }
    })
})
// 用户查询自己的全部的订单
router.post('/getOrderList', async (req,res)=>{
    let { keyWords='' } = req.body
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    
    const sql = `
        SELECT 
            a.*,
            b.nickName,
            b.email
        FROM orders a 
        LEFT JOIN user b ON a.userId = b.id 
        WHERE a.userId=? 
        AND a.adminId=? 
        AND (
            b.nickName LIKE CONCAT("%",?,"%")
            OR a.id LIKE CONCAT("%",?,"%")
            OR a.remark LIKE CONCAT("%",?,"%")
        )
        ORDER BY a.createTime DESC;
    `
    
    connection.query(sql,[info.id,info.adminId,keyWords,keyWords,keyWords],(err, results) => {
        if(err){
            console.log(err);
            res.status(500).send({
                status:1,
                message:'接口异常,请联系管理员',
                data:null
            })
            return
        }
        
        if(results && results.length){
            let data = results
            let orderContentIdArr = results.map(e => e.orderContentId).join(',')
            
            // 防止空数组导致的 SQL 错误
            if(!orderContentIdArr){
                res.send({
                    status:0,
                    message:'查询成功',
                    data:data
                })
                return
            }
            
            // 直接查询orderContent表获取订单详情
            connection.query(
                `SELECT * FROM orderContent WHERE orderContentId IN (${orderContentIdArr});`,
                [],
                (err, results) => {
                    if(results && results.length){
                        // 组装订单数据
                        data.forEach(order => {
                            order.list = results.filter(item => 
                                item.orderContentId === order.orderContentId
                            )
                            // 格式化时间
                            order.createTime = order.createTime ? 
                                new Date(order.createTime).toLocaleString() : null
                            order.updateTime = order.updateTime ? 
                                new Date(order.updateTime).toLocaleString() : null
                            order.payTime = order.payTime ? 
                                new Date(order.payTime).toLocaleString() : null
                            order.completeTime = order.completeTime ? 
                                new Date(order.completeTime).toLocaleString() : null
                        })
                        
                        res.send({
                            status:0,
                            message:'查询成功',
                            data:data
                        })
                    }else{
                        // 如果没有订单详情，也返回订单主表数据
                        res.send({
                            status:0,
                            message:'查询成功',
                            data:data
                        })
                    }
                }
            )
        }else{
            res.send({
                status:0,
                message:'查询成功',
                data:[]
            })
        }
    })
})
// 商家查询下单的订单
router.post('/getManageOrderList', async (req,res)=>{
    let { 
        keyWords='',          // 搜索关键词
        status='',            // 订单状态
        startTime='',         // 开始时间
        endTime='',          // 结束时间
        pageNum=1,           // 当前页码
        pageSize=10          // 每页条数
    } = req.body
    
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    
    try {
        pageNum = parseInt(pageNum)
        pageSize = parseInt(pageSize)
    } catch (error) {
        pageNum = 1
        pageSize = 10
    }
    
    // 构建查询条件
    let whereConditions = ['a.adminId = ?']
    let queryParams = [info.id]
    
    // 状态条件
    if(status !== ''){
        whereConditions.push('a.status = ?')
        queryParams.push(status)
    }
    
    // 时间范围条件
    if(startTime){
        whereConditions.push('a.createTime >= ?')
        queryParams.push(startTime)
    }
    if(endTime){
        whereConditions.push('a.createTime <= ?')
        queryParams.push(endTime)
    }
    
    // 关键词搜索条件
    if(keyWords){
        whereConditions.push(`(
            b.nickName LIKE CONCAT("%",?,"%")
            OR a.id LIKE CONCAT("%",?,"%")
            OR a.remark LIKE CONCAT("%",?,"%")
        )`)
        queryParams.push(keyWords, keyWords, keyWords)
    }
    
    // 构建完整的WHERE子句
    const whereClause = whereConditions.join(' AND ')
    
    // 查询总数
    const countSql = `
        SELECT COUNT(*) as total 
        FROM orders a 
        LEFT JOIN user b ON a.userId = b.id 
        WHERE ${whereClause}
    `
    
    // 查询数据
    const dataSql = `
        SELECT 
            a.*,
            b.nickName,
            b.email,
            b.balance
        FROM orders a 
        LEFT JOIN user b ON a.userId = b.id 
        WHERE ${whereClause}
        ORDER BY a.createTime DESC
        LIMIT ?, ?
    `
    
    // 执行查询
    connection.query(countSql, queryParams, (err, countResults) => {
        if(err){
            console.error('查询总数错误:', err)
            res.status(500).send({
                status:1,
                message:'接口异常,请联系管理员',
                data:null
            })
            return
        }
        
        const total = countResults[0].total
        
        // 添加分页参数
        queryParams.push((pageNum-1)*pageSize, pageSize)
        
        connection.query(dataSql, queryParams, (err, results) => {
            if(err){
                console.error('查询数据错误:', err)
                res.status(500).send({
                    status:1,
                    message:'接口异常,请联系管理员',
                    data:null
                })
                return
            }
            
            if(results && results.length){
                let data = results
                let orderContentIdArr = results.map(e => e.orderContentId).join(',')
                
                // 防止空数组导致的 SQL 错误
                if(!orderContentIdArr){
                    res.send({
                        status:0,
                        message:'查询成功',
                        data:{
                            list: data,
                            total,
                            pageNum,
                            pageSize
                        }
                    })
                    return
                }
                
                // 查询订单详情
                connection.query(
                    `SELECT * FROM orderContent WHERE orderContentId IN (${orderContentIdArr});`,
                    [],
                    (err, detailResults) => {
                        if(err){
                            console.error('查询订单详情错误:', err)
                            res.status(500).send({
                                status:1,
                                message:'接口异常,请联系管理员',
                                data:null
                            })
                            return
                        }
                        
                        if(detailResults && detailResults.length){
                            // 组装订单数据
                            data.forEach(order => {
                                order.list = detailResults.filter(item => 
                                    item.orderContentId === order.orderContentId
                                )
                                // 格式化时间
                                order.createTime = order.createTime ? 
                                    new Date(order.createTime).toLocaleString() : null
                                order.updateTime = order.updateTime ? 
                                    new Date(order.updateTime).toLocaleString() : null
                                order.payTime = order.payTime ? 
                                    new Date(order.payTime).toLocaleString() : null
                                order.completeTime = order.completeTime ? 
                                    new Date(order.completeTime).toLocaleString() : null
                            })
                        }
                        
                        res.send({
                            status:0,
                            message:'查询成功',
                            data:{
                                list: data,
                                total,
                                pageNum,
                                pageSize
                            }
                        })
                    }
                )
            }else{
                res.send({
                    status:0,
                    message:'查询成功',
                    data:{
                        list: [],
                        total: 0,
                        pageNum,
                        pageSize
                    }
                })
            }
        })
    })
})
// 更新订单状态
router.post('/setOrderStatus', async (req,res)=>{
    const { status, id, cancelReason = '' } = req.body
    
    // 获取当前时间
    const now = new Date()
    
    // 根据状态设置不同的更新字段
    let updateFields = {
        status,
        updateTime: now
    }
    
    // 根据不同状态设置相应的时间字段
    switch(status) {
        case 4: // 完成
            updateFields.completeTime = now
            break
        case 5: // 取消
            updateFields.cancelTime = now
            updateFields.cancelReason = cancelReason
            break
    }
    
    // 构建更新SQL
    const updateSql = Object.keys(updateFields)
        .map(key => `${key}=?`)
        .join(',')
    
    const values = [...Object.values(updateFields), id]
    
    connection.query(
        `UPDATE orders SET ${updateSql} WHERE id=?`,
        values,
        (err, results) => {
            if(results && results.affectedRows==1){
                res.send({
                    status:0,
                    message:'更新成功',
                    data:null
                })
            }else{
                res.status(500).send({
                    status:1,
                    message:'接口异常,请联系管理员',
                    data:null
                })
            }
        }
    )
})


// 用户注册
router.post('/addUser', async (req,res)=>{
    if(req.body){
        // 注册校验
        let pass = false
        if(req.body.userName && req.body.passWord && req.body.nickName && req.body.email && req.body.code){
            pass = true
        }
        if(!pass){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'参数异常', //状态描述
                data:null		  // 需要响应给客户端的具体数据
            })
            return
        }

        // 验证码校验
        const sql = "SELECT * FROM verification_code WHERE email = ? AND code = ? AND is_used = 0 AND expire_time > NOW() ORDER BY create_time DESC LIMIT 1"
        connection.query(sql, [req.body.email, req.body.code], async (err, results) => {
            if (err || !results.length) {
                res.status(500).send({
                    status: 1,
                    message: '验证码无效或已过期',
                    data: null
                })
                return
            }

            // 将验证码标记为已使用
            const updateSql = "UPDATE verification_code SET is_used = 1 WHERE id = ?"
            connection.query(updateSql, [results[0].id])

            req.body.passWord = rsa.privateDecrypt(req.body.passWord);
            req.body.passWord = bcrypt.hashSync(req.body.passWord, 10)
            // 用户名校验重复
            connection.query('SELECT id FROM user WHERE userName=?;',[req.body.userName],(err, results) => {
                if (results&&results.length) {
                    res.status(500).send({
                        status:1,			//状态，0表示成功，1表示失败
                        message:'用户名已被注册', //状态描述
                        data:null		  // 需要响应给客户端的具体数据
                    })
                    return;
                }
                // 校验通过
                req.body.id = parseInt(Math.random() * 1000000000000)
                req.body.createTime = new Date()
                req.body.balance = 0//余额
                const sql = "INSERT INTO user(`id`,`userName`,`passWord`,`nickName`,`createTime`,`balance`,`adminId`,`email`) VALUES (?,?,?,?,?,?,?,?)";
                const params = [req.body.id,req.body.userName,req.body.passWord,req.body.nickName,req.body.createTime,req.body.balance,req.body.id,req.body.email];
                connection.query(sql, params, (err, results) => {
                    if (err) {
                        res.status(500).send({
                            status:1,			//状态，0表示成功，1表示失败
                            message:'用户创建失败,请联系管理员', //状态描述
                            data:null		  // 需要响应给客户端的具体数据
                        })
                        return;
                    }
                    res.send({
                        status:0,			//状态，0表示成功，1表示失败
                        message:'用户创建成功', //状态描述
                        data:req.body.id		  // 需要响应给客户端的具体数据
                    })
                });
            });
        });
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'参数缺失', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})
// 发送验证码
router.post('/sendVerificationCode', async (req, res) => {
    if (!req.body.email) {
        res.status(500).send({
            status: 1,
            message: '邮箱不能为空',
            data: null
        })
        return
    }

    // 检查今天该邮箱发送验证码的次数
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    const sql = "SELECT COUNT(*) as count FROM verification_code WHERE email = ? AND create_time >= ?"
    connection.query(sql, [req.body.email, today], async (err, results) => {
        if (err) {
            res.status(500).send({
                status: 1,
                message: '系统错误',
                data: null
            })
            return
        }

        if (results[0].count >= 3) {
            res.status(500).send({
                status: 1,
                message: '该邮箱今日发送验证码次数已达上限，请明天再试',
                data: null
            })
            return
        }

        // 生成6位随机验证码
        const code = Math.random().toString().slice(-6)
        const now = new Date()
        const expireTime = new Date(now.getTime() + 10 * 60 * 1000) // 10分钟后过期

        // 保存验证码到数据库
        const verificationData = {
            id: parseInt(Math.random() * 1000000000000),
            email: req.body.email,
            code: code,
            create_time: now,
            expire_time: expireTime,
            is_used: 0
        }

        const insertSql = "INSERT INTO verification_code SET ?"
        connection.query(insertSql, verificationData, async (err, results) => {
            if (err) {
                res.status(500).send({
                    status: 1,
                    message: '验证码生成失败',
                    data: null
                })
                return
            }

            // 发送验证码邮件
            try {
                await transport.sendMail({
                    from: '3241928859@qq.com',
                    to: req.body.email,
                    subject: '小猪点菜 - 注册/修改密码验证码',
                    html: `<div style="padding: 20px; background-color: #f8f8f8; border-radius: 5px;">
                            <h2 style="color: #ff6096;">小猪点菜</h2>
                            <p>您的验证码是：<strong style="color: #ff6096; font-size: 20px;">${code}</strong></p>
                            <p>验证码有效期为10分钟，请尽快使用。</p>
                            <p style="color: #999; font-size: 12px;">如果这不是您的操作，请忽略此邮件。</p>
                          </div>`
                })

                res.send({
                    status: 0,
                    message: '验证码发送成功',
                    data: null
                })
            } catch (error) {
                res.status(500).send({
                    status: 1,
                    message: '验证码发送失败',
                    data: null
                })
            }
        })
    })
})

// 修改密码
router.post('/resetPassword', async (req, res) => {
    const { email, code, newPassword } = req.body

    if (!email || !code || !newPassword) {
        res.status(500).send({
            status: 1,
            message: '参数不完整',
            data: null
        })
        return
    }

    // 验证码校验
    const sql = "SELECT * FROM verification_code WHERE email = ? AND code = ? AND is_used = 0 AND expire_time > NOW() ORDER BY create_time DESC LIMIT 1"
    connection.query(sql, [email, code], async (err, results) => {
        if (err || !results.length) {
            res.status(500).send({
                status: 1,
                message: '验证码无效或已过期',
                data: null
            })
            return
        }

        // 将验证码标记为已使用
        const updateSql = "UPDATE verification_code SET is_used = 1 WHERE id = ?"
        connection.query(updateSql, [results[0].id])

        // 更新密码
        const hashedPassword = bcrypt.hashSync(rsa.privateDecrypt(newPassword), 10)
        const updatePasswordSql = "UPDATE user SET passWord = ? WHERE email = ?"
        connection.query(updatePasswordSql, [hashedPassword, email], (err, results) => {
            if (err) {
                res.status(500).send({
                    status: 1,
                    message: '密码修改失败',
                    data: null
                })
                return
            }

            res.send({
                status: 0,
                message: '密码修改成功',
                data: null
            })
        })
    })
})

// 用户登录
router.post('/login', async (req,res)=>{
    req.body.passWord = rsa.privateDecrypt(req.body.passWord);
    connection.query('SELECT id,passWord FROM user WHERE userName=?;',[req.body.userName],(err, results) => {
        if(results&&results.length){
            // 拿着用户输入的密码,和数据库中存储的密码进行对比
            const compareResult = bcrypt.compareSync(req.body.passWord, results[0].passWord)
            if(!compareResult){
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'用户名或密码不正确', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
                return
            }
            let token = JWT.createToken({id:results[0].id},60*60*24)
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'登录成功', //状态描述
                data:token          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'登录失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 获取当前用户信息
router.get('/getCurrentUser', async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    console.log(info);
    
    if(info){
        res.send({
            status:0,			//状态，0表示成功，1表示失败
            message:'获取成功', //状态描述
            data:info          // 需要响应给客户端的具体数据
        })
    }else{
        res.status(401).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'登录过期,请先登录', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
    }
})
// 根据昵称、编号查询用户
router.post('/queryUserList', async (req,res)=>{
    let { keyWords="",pageNum=1,pageSize=5 } = req.body
    try {
        pageNum = parseInt(pageNum)
        pageSize = parseInt(pageSize)
    } catch (error) {
        pageNum = 1
        pageSize = 5
    }
    connection.query('SELECT * FROM user WHERE nickName LIKE CONCAT("%",?,"%") OR idNo LIKE CONCAT("%",?,"%") LIMIT ?, ?;',[keyWords,keyWords,(pageNum-1)*pageSize,pageSize],(err, results) => {
        console.log(err,results);
        
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 余额充值
router.post('/recharge', async (req,res)=>{
    if(req.body){
        let token = req.get('Authorization')
        let info = await getUserInfo(token)
        const { balance,key } = req.body
        if(key != '爸爸'){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'口令错误，充值失败', //状态描述
                data:null		  // 需要响应给客户端的具体数据
            })
            return
        }
        let pass =  await changePrice(info.id,'add',balance,info.balance)
        if(pass){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'充值成功', //状态描述
                data:null		  // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'接口异常,请联系管理员', //状态描述
                data:null		  // 需要响应给客户端的具体数据
            })
        }
    }else{
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'充值失败,请联系管理员', //状态描述
            data:null		  // 需要响应给客户端的具体数据
        })
    }
})

// 设置谁可见菜单
router.get('/setMenuView', async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    console.log(info.id , req.query.id);
    if(info.id == req.query.id){
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'无法关联自己', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
        return
    }
    connection.query('SELECT id FROM user WHERE id=?;',[req.query.id],(err, results) => {
        if(results&&results.length){
            connection.query("INSERT INTO menuView(`userId`,`adminId`) VALUES (?,?)",[req.query.id,info.id],(err, results) => {
                if(err){
                    res.status(500).send({
                        status:1,			//状态，0表示成功，1表示失败
                        message:'该用户已关联，请勿重复关联', //状态描述
                        data:null          // 需要响应给客户端的具体数据
                    })
                    return
                }
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'用户关联成功', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'关联用户不存在', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 查询菜单可见用户列表
router.post('/getMenuViewList', async (req,res)=>{
    const { keyWords="" } = req.body
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT u.* FROM user u JOIN menuView mv ON u.id = mv.userId WHERE mv.adminId = ? AND (u.nickName LIKE CONCAT("%",?,"%") OR u.idNo LIKE CONCAT("%",?,"%"));',[info.id,keyWords,keyWords],(err, results) => {
        if(results || results == []){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 删除菜单可见用户
router.get('/deleteMenuViewUser', async (req,res)=>{
    let { userId } = req.query
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query("DELETE FROM menuView WHERE userId = ? AND adminId = ?;",[userId,info.id],(err, results) => {
        console.log(err,results);
        if(err || results.affectedRows == 0){
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'删除失败', //状态描述
                data:err          // 需要响应给客户端的具体数据
            })
            return
        }
        // 同步取消所有关联用户的关联
        connection.query('UPDATE user set adminId=user.id WHERE adminId=?',[info.id],(err, results) => {
            if(err){
                res.status(500).send({
                    status:1,			//状态，0表示成功，1表示失败
                    message:'系统异常，请联系管理员', //状态描述
                    data:err          // 需要响应给客户端的具体数据
                })
                return
            }else{
                res.send({
                    status:0,			//状态，0表示成功，1表示失败
                    message:'删除成功', //状态描述
                    data:null          // 需要响应给客户端的具体数据
                })
            }
        })
       
    })
})
// 查询可关联的对象
router.get('/getUserViewList', async (req,res)=>{
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('SELECT u.* FROM user u JOIN menuView mv ON u.id = mv.adminId WHERE mv.userId = ?;',[info.id],(err, results) => {
        if(results || results == []){
            results = [info,...results]
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'查询成功', //状态描述
                data:results          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'查询失败', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 关联admin对象
router.get('/updateConnectAdmin', async (req,res)=>{
    const { adminId } = req.query
    if(!adminId){
        res.status(500).send({
            status:1,			//状态，0表示成功，1表示失败
            message:'参数异常', //状态描述
            data:null          // 需要响应给客户端的具体数据
        })
        return
    }
    let token = req.get('Authorization')
    let info = await getUserInfo(token)
    connection.query('UPDATE user set adminId=? WHERE id=?',[adminId,info.id],(err, results) => {
        console.log(results);
        if(results.affectedRows==1){
            res.send({
                status:0,			//状态，0表示成功，1表示失败
                message:'关联成功', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }else{
            res.status(500).send({
                status:1,			//状态，0表示成功，1表示失败
                message:'接口异常，请联系管理员', //状态描述
                data:null          // 需要响应给客户端的具体数据
            })
        }
    })
})
// 变更用户余额
function changePrice(id,type,sum,balance){
    return new Promise((resolve, reject) => {
        let newBalance = 0
        if(type=='add'){
            newBalance = parseFloat(balance) + parseFloat(sum)
        }else{
            newBalance = parseFloat(balance) - parseFloat(sum)
        }
        connection.query('UPDATE user set balance=? WHERE id=?',[newBalance,id],(err, results) => {
            console.log(err,results);
            if(results&&results.affectedRows==1){
                resolve(true)
            }else{
                resolve(false)
            }
        })
    })
}


module.exports = router;
